Möchten Sie diesen Beitrag verbessern? Geben Sie detaillierte Antworten auf diese Frage, einschließlich Zitaten und einer Erklärung, warum Ihre Antwort richtig ist. Antworten ohne ausreichende Details können bearbeitet oder gelöscht werden. Was sind die Unterschiede zwischen Git Pull und Git Fetch?
2020-12-07 13:16:50
1 2 Nächster Im einfachsten Fall führt Git Pull einen Git-Abruf durch, gefolgt von einer Git-Zusammenführung. Sie können jederzeit einen Git-Abruf durchführen, um Ihre Remote-Tracking-Zweige unter refs / remotes // zu aktualisieren. Dieser Vorgang ändert niemals eine Ihrer eigenen lokalen Niederlassungen unter Refs / Heads und kann ohne Änderung Ihrer Arbeitskopie durchgeführt werden. Ich habe sogar von Leuten gehört, die regelmäßig Git-Fetch in einem Cron-Job im Hintergrund ausführen (obwohl ich dies nicht empfehlen würde). Mit einem Git-Pull würden Sie einen lokalen Zweig mit seiner Remote-Version auf den neuesten Stand bringen und gleichzeitig Ihre anderen Remote-Tracking-Zweige aktualisieren. Aus der Git-Dokumentation für Git Pull: Im Standardmodus ist Git Pull eine Abkürzung für Git Fetch, gefolgt von Git Merge FETCH_HEAD. | Wenn Sie Pull verwenden, versucht Git, Ihre Arbeit automatisch für Sie zu erledigen. Es ist kontextsensitiv, sodass Git alle gezogenen Commits in dem Zweig zusammenführt, in dem Sie gerade arbeiten. Pull führt die Commits automatisch zusammen, ohne dass Sie sie zuerst überprüfen müssen. Wenn Sie Ihre Filialen nicht genau verwalten, kann es häufig zu Konflikten kommen. Beim Abrufen sammelt Git alle Commits aus dem Zielzweig, die in Ihrem aktuellen Zweig nicht vorhanden sind, und speichert sie in Ihrem lokalen Repository. Sie werden jedoch nicht mit Ihrem aktuellen Zweig zusammengeführt. Dies ist besonders nützlich, wenn Sie Ihr Repository auf dem neuesten Stand halten müssen, aber an etwas arbeiten, das beim Aktualisieren Ihrer Dateien möglicherweise kaputt geht. Um die Commits in Ihren Hauptzweig zu integrieren, verwenden Sie Merge. | Es ist wichtig, die Designphilosophie von git der Philosophie eines traditionelleren Versionsverwaltungswerkzeugs wie SVN gegenüberzustellen. Subversion wurde mit einem Client / Server-Modell entworfen und erstellt. Es gibt ein einziges Repository, das der Server ist, und mehrere Clients können Code vom Server abrufen, daran arbeiten und ihn dann wieder auf den Server übertragen. Es wird davon ausgegangen, dass der Client immer dann mit dem Server Kontakt aufnehmen kann, wenn er eine Operation ausführen muss. Git wurde entwickelt, um ein verteilteres Modell zu unterstützen, ohne dass ein zentrales Repository erforderlich ist (obwohl Sie sicherlich eines verwenden können, wenn Sie möchten). Außerdem wurde git so konzipiert, dass der Client und der "Server" nicht gleichzeitig online sein müssen. Git wurde so konzipiert, dass Personen mit einem unzuverlässigen Link sogar Code per E-Mail austauschen können. Es ist möglich, vollständig getrennt zu arbeiten und eine CD zu brennen, um Code über Git auszutauschen. Um dieses Modell zu unterstützen, verwaltet git ein lokales Repository mit Ihrem Code sowie ein zusätzliches lokales Repository, das den Status des Remote-Repositorys widerspiegelt. Indem eine Kopie des Remote-Repositorys lokal aufbewahrt wird, kann git die erforderlichen Änderungen herausfinden, auch wenn das Remote-Repository nicht erreichbar ist. Wenn Sie die Änderungen später an eine andere Person senden müssen, kann git sie als eine Reihe von Änderungen ab einem dem Remote-Repository bekannten Zeitpunkt übertragen. git fetch ist der Befehl "Meine lokale Kopie des Remote-Repositorys auf den neuesten Stand bringen". git pull sagt: "Bringe die Änderungen im Remote-Repository dahin, wo ich meinen eigenen Code aufbewahre." Normalerweise führt Git Pull dies durch, indem es einen Git-Abruf durchführt, um die lokale Kopie des Remote-Repositorys auf den neuesten Stand zu bringen, und dann die Änderungen in Ihrem eigenen Code-Repository und möglicherweise in Ihrer Arbeitskopie zusammenführt. Beachten Sie, dass sich auf Ihrer Workstation häufig mindestens drei Kopien eines Projekts befinden. Eine Kopie ist Ihr eigenes Repository mit Ihrem eigenen Commit-Verlauf. Die zweite Kopie ist Ihre Arbeitskopie, in der Sie bearbeiten und erstellen. Die dritte Kopie ist Ihre lokale "zwischengespeicherte" Kopie eines Remote-Repositorys. | Hier ist Oliver Steeles Bild davon, wie alles zusammen passt: Wenn es genügend Interesse gibt, könnte ich das Bild wahrscheinlich aktualisieren, um Git-Klon und Git-Merge hinzuzufügen ... | Ein Anwendungsfall von Git Fetch ist, dass im Folgenden alle Änderungen in der Remote-Verzweigung seit Ihrem letzten Abruf angezeigt werden. Sie können also vor dem eigentlichen Abrufen überprüfen, ob sich die Dateien in Ihrer aktuellen Verzweigung und Arbeitskopie ändern könnten. Git holen Git Diff ... Herkunft Informationen zur Doppel- und Dreifachpunktsyntax im Befehl diff finden Sie unter: https://git-scm.com/docs/git-diff | Es hat mich ein bisschen gekostet zu verstehen, was der Unterschied war, aber das ist eine einfache Erklärung. Master in Ihrem lokalen Host ist eine Niederlassung. Wenn Sie ein Repository klonen, rufen Sie das gesamte Repository zu Ihrem lokalen Host ab. Dies bedeutet, dass Sie zu diesem Zeitpunkt einen Ursprungs- / Master-Zeiger auf HEAD und einen Master-Zeiger auf denselben HEAD haben. Wenn Sie anfangen zu arbeiten und Commits ausführen, bewegen Sie den Master-Zeiger auf HEAD + Ihre Commits. Der Ursprungs- / Master-Zeiger zeigt jedoch immer noch auf das, was er beim Klonen war. Der Unterschied wird also sein: Wenn Sie einen Git-Abruf durchführen, werden nur alle Änderungen im Remote-Repository (GitHub) abgerufen und der Ursprungs- / Master-Zeiger auf HEAD verschoben. In der Zwischenzeit zeigt Ihr lokaler Filialleiter immer wieder darauf, wo er sich befindet. Wenn Sie einen Git-Pull ausführen, wird dieser im Grunde genommen (wie zuvor erläutert) abgerufen und alle neuen Änderungen an Ihrem Computer werden zusammengeführtMaster-Zweig und bewegen Sie den Zeiger auf HEAD. | Manchmal hilft eine visuelle Darstellung. | Kurz Git Fetch ähnelt Pull, wird jedoch nicht zusammengeführt. d.h. es ruft Remote-Updates (Refs und Objekte) ab, aber Ihr lokales bleibt gleich (d. h. Ursprung / Master wird aktualisiert, aber Master bleibt gleich). Git Pull wird von einer Fernbedienung heruntergezogen und sofort zusammengeführt. Mehr Git Clone klont ein Repo. git rebase speichert Daten aus Ihrem aktuellen Zweig, die sich nicht im Upstream-Zweig befinden, in einem temporären Bereich. Ihre Filiale ist jetzt dieselbe wie vor Beginn Ihrer Änderungen. Git pull -rebase ruft also die Remote-Änderungen ab, spult Ihren lokalen Zweig zurück und spielt Ihre Änderungen nacheinander über den aktuellen Zweig hinaus ab, bis Sie auf dem neuesten Stand sind. Außerdem zeigt Ihnen git branch -a genau, was mit all Ihren Filialen los ist - lokal und remote. Dieser Blog-Beitrag war nützlich: Der Unterschied zwischen Git Pull, Git Fetch und Git Clone (und Git Rebase) - Mike Pearce und deckt Git Pull, Git Fetch, Git Clone und Git Rebase ab. ==== AKTUALISIEREN Ich dachte, ich würde dies aktualisieren, um zu zeigen, wie Sie dies in der Praxis tatsächlich verwenden würden. Aktualisieren Sie Ihr lokales Repo von der Fernbedienung (aber nicht zusammenführen): Git holen Lassen Sie uns nach dem Herunterladen der Updates die Unterschiede sehen: Git Diff Master Herkunft / Master Wenn Sie mit diesen Updates zufrieden sind, führen Sie Folgendes zusammen: Git Pull Anmerkungen: Zu Schritt 2: Weitere Informationen zu Unterschieden zwischen lokalen und Fernbedienungen finden Sie unter: Wie vergleiche ich einen lokalen Git-Zweig mit seinem Remote-Zweig? Zu Schritt 3: Es ist wahrscheinlich genauer (z. B. bei einem sich schnell ändernden Repo), hier einen Git-Rebase-Ursprung zu erstellen. Siehe @ Justin Ohms Kommentar in einer anderen Antwort. Siehe auch: http://longair.net/blog/2009/04/16/git-fetch-and-merge/ | git-pull - Abrufen aus einem anderen Repository oder einem lokalen Zweig und Zusammenführen mit diesem ZUSAMMENFASSUNG Git Pull ... BESCHREIBUNG Führt git-fetch mit den angegebenen Parametern aus und ruft git-merge auf, um das zusammenzuführen Kopf (e) in den aktuellen Zweig abgerufen. Ruft mit --rebase git-rebase auf statt git-merge. Beachten Sie, dass Sie verwenden können. (aktuelles Verzeichnis) als zum Abrufen aus dem lokalen Repository - Dies ist nützlich, wenn lokale Zweige zusammengeführt werden in den aktuellen Zweig. Beachten Sie auch, dass Optionen für das Git-Pull selbst und das zugrunde liegende Git-Merge gedacht sind muss vor den für git-fetch vorgesehenen Optionen angegeben werden. Sie würden ziehen, wenn Sie möchten, dass die Historien zusammengeführt werden. Sie würden abrufen, wenn Sie nur den Codez möchten, da eine Person hier einige Artikel markiert hat. | Sie können aus einem Remote-Repository abrufen, die Unterschiede anzeigen und dann ziehen oder zusammenführen. Dies ist ein Beispiel für ein Remote-Repository namens origin und einen Zweig namens master, der den Ursprung / Master des Remote-Zweigs verfolgt: Git Checkout Master Git holen Git Diff Herkunft / Master Git Rebase Origin Master | Die kurze und einfache Antwort lautet: Git Pull ist einfach Git Fetch, gefolgt von Git Merge. Es ist sehr wichtig zu beachten, dass Git Pull automatisch zusammengeführt wird, ob Sie es mögen oder nicht. Dies könnte natürlich zu Zusammenführungskonflikten führen. Angenommen, Ihre Fernbedienung ist Ursprung und Ihr Zweig ist Master. Wenn Sie vor dem Ziehen einen unterschiedlichen Ursprung / Master angeben, sollten Sie eine Vorstellung von möglichen Zusammenführungskonflikten haben und Ihren lokalen Zweig entsprechend vorbereiten können. Zusätzlich zum Ziehen und Schieben beinhalten einige Workflows eine Git-Rebase, wie diese, die ich aus dem verlinkten Artikel umschreibe: Git Pull Origin Master Git Checkout Foo-Branch Git Rebase Master Git Push Origin Foo-Branch Wenn Sie sich in einer solchen Situation befinden, könnten Sie versucht sein, Pull-Rebase zu spielen. Wenn Sie nicht wirklich wissen, was Sie tun, würde ich davon abraten. Diese Warnung stammt aus der Manpage für Git-Pull, Version 2.3.5: Dies ist eine potenziell gefährliche Betriebsart. Es schreibt neu Geschichte, was nicht gut ist, wenn Sie diese Geschichte veröffentlicht haben bereits. Verwenden Sie diese Option nur, wenn Sie git-rebase (1) gelesen haben. vorsichtig. | OK, hier sind einige Informationen zu Git Pull und Git Fetch, damit Sie die tatsächlichen Unterschiede verstehen können. In wenigen einfachen Worten erhält Fetch die neuesten Daten, aber nicht die Codeänderungen und wird nicht mit Ihrem aktuellen lokalen Zweigcode in Konflikt geraten , aber ziehen Sie, um die Codeänderungen zu erhalten und sie in Ihrem lokalen Zweig zusammenzuführen. Lesen Sie weiter, um weitere Details zu jedem zu erhalten: Git holen Es werden alle Refs und Objekte sowie alle neuen Zweige in Ihr lokales Repository heruntergeladen ... Rufen Sie Zweige und / oder Tags (zusammen "refs") von einem oder mehreren ab andere Repositorys, zusammen mit den Objekten, die zur Vervollständigung ihrer erforderlich sind Geschichten. Remote-Tracking-Zweige werden aktualisiert (siehe Beschreibung von unten für Möglichkeiten zur Steuerung dieses Verhaltens). Standardmäßig ist jedes Tag, das auf die abgerufenen Historien verweist, " auch geholt; Der Effekt besteht darin, Tags abzurufen, die auf Zweige zeigen, die Sie interessieren sich für. Dieses Standardverhalten kann mithilfe von geändert werden die Optionen --tags oder --no-tags oder durch Konfigurieren remote..tagOpt. Durch die Verwendung einer Referenzspezifikation, die Tags explizit abruft, Sie können Tags abrufen, die nicht auf interessierte Zweige verweisen in auch. Git Fetch kann abrufen vonentweder ein einzelnes benanntes Repository oder eine URL oder aus mehreren Repositories gleichzeitig, wenn gegeben ist und es eine gibt Fernbedienungen. Eintrag in der Konfigurationsdatei. (Siehe git-config1). Wenn keine Fernbedienung angegeben ist, ist die Ursprungsfernbedienung standardmäßig verwendet, es sei denn, es ist ein Upstream-Zweig für den aktuellen konfiguriert Ast. Die Namen der abgerufenen Refs zusammen mit den Objektnamen Sie zeigen auf .git / FETCH_HEAD. Diese Informationen können sein Wird von Skripten oder anderen Git-Befehlen wie Git-Pull verwendet. Git Pull Es werden die Änderungen von Remote auf den aktuellen Zweig in lokalen ... Integriert Änderungen aus einem Remote-Repository in den aktuellen Zweig. Im Standardmodus ist Git Pull eine Abkürzung für Git Fetch, gefolgt von git merge FETCH_HEAD. Genauer gesagt führt git pull git fetch mit den angegebenen Parametern und aus ruft git merge auf, um die abgerufenen Verzweigungsköpfe mit dem aktuellen zusammenzuführen Ast. Mit --rebase wird git rebase anstelle von git merge ausgeführt. sollte der Name eines Remote-Repositorys sein, an das übergeben wird git-fetch1. kann eine beliebige Remote-Referenz benennen (z. den Namen eines Tags) oder sogar eine Sammlung von Referenzen mit entsprechenden Fernverfolgungszweige (z. B. refs / heads /: refs / remotes / origin /), In der Regel ist dies jedoch der Name eines Zweigs im Remote-Repository. Standardwerte für und werden aus dem gelesen "Remote" - und "Merge" -Konfiguration für den aktuellen Zweig, wie von festgelegt Git-Branch --track. Ich erstelle auch das folgende Bild, um Ihnen zu zeigen, wie Git Fetch und Git Pull zusammenarbeiten ... | Diese interaktive grafische Darstellung ist sehr hilfreich, um Git zu verstehen: http://ndpsoftware.com/git-cheatsheet.html git fetch "lädt" nur die Änderungen von der Fernbedienung in Ihr lokales Repository herunter. git pull lädt die Änderungen herunter und führt sie in Ihrem aktuellen Zweig zusammen. "Im Standardmodus ist Git Pull eine Abkürzung für Git Fetch, gefolgt von Git Merge FETCH_HEAD." | Bonus: Wenn ich in den obigen Antworten von Pull & Fetch spreche, möchte ich einen interessanten Trick teilen: Git Pull - Rebase Dieser obige Befehl ist der nützlichste Befehl in meinem Git-Leben, der viel Zeit gespart hat. Versuchen Sie diesen Befehl, bevor Sie Ihre neuen Commits auf den Server übertragen. Die neuesten Serveränderungen werden automatisch synchronisiert (mit einem Abruf + Zusammenführen) und Ihr Commit wird im Git-Protokoll ganz oben platziert. Sie müssen sich keine Gedanken über manuelles Ziehen / Zusammenführen machen. Details finden Sie unter: http://gitolite.com/git-pull--rebase | Ich möchte eine visuelle Darstellung der Situation haben, um diese Dinge zu erfassen. Vielleicht möchten es auch andere Entwickler sehen, also hier ist meine Ergänzung. Ich bin mir nicht ganz sicher, ob alles korrekt ist. Bitte kommentieren Sie, wenn Sie Fehler finden. LOKALES SYSTEM . ================================================== === =================. ======================================================= REMOTE REPOSITORY. REMOTE REPOSITORY LOKALE REPOSITORY ARBEITSKOPIE (URSPRUNG) . (CACHED) zum Beispiel, . Spiegel der ein Github Repo. . Remote Repo Kann auch sein . mehrere Repos. . . FETCH * ------------------> * Ihr lokaler Cache der Fernbedienung wird mit dem Ursprung (oder mehreren) aktualisiert externe Quellen, das ist die verteilte Natur von git) . ZIEHEN *------------------------------------------------ --------> * Änderungen werden direkt in Ihre lokale Kopie übernommen. wenn Konflikte auftreten, Sie werden um Entscheidungen gebeten. . VERPFLICHTEN . * <--------------- * Wenn Sie beispielsweise von Subversion kommen, denken Sie vielleicht, dass es sich um ein Commit handelt aktualisiert den Ursprung. In git wird ein Commit nur für Ihr lokales Repo durchgeführt. . PUSH * <--------------------------------------- * Synchronisiert Ihre Änderungen wieder in den Ursprung. Einige Hauptvorteile für einen abgerufenen Spiegel der Fernbedienung sind: Leistung (scrollen Sie durch alle Commits und Nachrichten, ohne zu versuchen, sie durch das Netzwerk zu drücken) Feedback zum Status Ihres lokalen Repos (zum Beispiel verwende ich den SourceTree von Atlassian, der mir eine Glühbirne gibt, die anzeigt, ob ich im Vergleich zum Ursprung vor oder hinter mir bin. Diese Informationen können mit einem GIT FETCH aktualisiert werden). | Ich habe auch damit zu kämpfen. Tatsächlich bin ich mit einer Google-Suche genau der gleichen Frage hierher gekommen. Das Lesen all dieser Antworten hat mir schließlich ein Bild in den Kopf gemalt, und ich habe mich entschlossen, den Zustand der 2 Repositorys und 1 Sandbox sowie die im Laufe der Zeit ausgeführten Aktionen zu überprüfen, während ich mir die Version davon angesehen habe. Also hier ist, was ich mir ausgedacht habe. Bitte korrigieren Sie mich, wenn ich irgendwo etwas durcheinander gebracht habe. Die drei Repos mit einem Fetch: --------------------- ----------------------- ------ ----------------- - Remote Repo - - Remote Repo - - Remote Repo - - - - wird geschoben - - - - @ R01 - - @ R02 - - @ R02 - --------------------- ----------------------- ------ ----------------- --------------------- ---------------------------------------------- - Lokales Repo - - Lokales Repo - - Lokales Repo - - ziehen - - - - holen - - @ R01 - - @ R01 - - @ R02 - --------------------- ----------------------- ------ ----------------- --------------------- ----------------------- ------ ----------------- - Lokale Sandbox - - Lokale Sandbox - - Lokale Sandbox - - Kasse - - neue Arbeit erledigt - - - - @ R01 - - @ R01 + - - @ R01 + - --------------------- ----------------------- ------ ----------------- Die drei Repos mit einem Zug --------------------- ----------------------- ------ ----------------- - Remote Repo - - Remote Repo - - Remote Repo - - - - wird geschoben - - - - @ R01 - - @ R02 - - @ R02 - --------------------- ----------------------- ------ ----------------- --------------------- ----------------------- ------ ----------------- - Lokales Repo - - Lokales Repo - - Lokales Repo - - ziehen - - - - ziehen - - @ R01 - - @ R01 - - @ R02 - --------------------- ----------------------- ------ ----------------- --------------------- ----------------------- ------ ----------------- - Lokale Sandbox - - Lokale Sandbox - - Lokale Sandbox - - Kasse - - neue Arbeit erledigt - - mit R02 zusammengeführt - - @ R01 - - @ R01 + - - @ R02 + - --------------------- ----------------------- ------ ----------------- Dies half mir zu verstehen, warum ein Abruf ziemlich wichtig ist. | Der Unterschied zwischen GIT Fetch und GIT Pull kann mit dem folgenden Szenario erklärt werden: (Denken Sie daran, dass Bilder lauter sprechen als Worte! Ich habe eine bildliche Darstellung bereitgestellt.) Nehmen wir ein Beispiel, in dem Sie mit Ihren Teammitgliedern an einem Projekt arbeiten. Es wird also einen Hauptzweig des Projekts geben, und alle Mitwirkenden müssen ihn in ihr eigenes lokales Repository aufteilen und dann an diesem lokalen Zweig arbeiten, um Module zu ändern / hinzuzufügen, und dann zum Hauptzweig zurückkehren. Damit, Der Anfangszustand der beiden Zweige, als Sie das Hauptprojekt in Ihrem lokalen Repository gegabelt haben, ist wie folgt: (A, B und C sind Module, die bereits vom Projekt abgeschlossen wurden.) Jetzt haben Sie begonnen, an dem neuen Modul zu arbeiten (angenommen D), und wenn Sie das D-Modul abgeschlossen haben, möchten Sie es in den Hauptzweig verschieben. In der Zwischenzeit hat einer Ihrer Teamkollegen das neue Modul E, F und entwickelt modifiziertes C. Was nun passiert ist, ist, dass Ihr lokales Repository hinter dem ursprünglichen Fortschritt des Projekts fehlt und das Übertragen Ihrer Änderungen auf den Hauptzweig zu Konflikten führen und zu Fehlfunktionen Ihres Moduls D führen kann. Um solche Probleme zu vermeiden und parallel zum ursprünglichen Projektfortschritt zu arbeiten, gibt es zwei Möglichkeiten: 1. Git Fetch- Hiermit werden alle Änderungen heruntergeladen, die am Ursprungs- / Hauptzweigprojekt vorgenommen wurden und in Ihrem lokalen Zweig nicht vorhanden sind. Und wartet darauf, dass der Befehl Git Merge die Änderungen übernimmt, die in Ihr Repository oder Ihren Zweig abgerufen wurden. Jetzt können Sie die Dateien sorgfältig überwachen, bevor Sie sie mit Ihrem Repository zusammenführen. Außerdem können Sie D bei Bedarf aufgrund von Modified C ändern. 2. Git Pull - Hiermit wird Ihr lokaler Zweig mit dem Ursprungs- / Hauptzweig aktualisiert, d. H. Eine Kombination aus Git Fetch und Git Merge nacheinander. Dies kann jedoch zu Konflikten führen. Es wird daher empfohlen, Git Pull mit einer sauberen Kopie zu verwenden. | Wir sagen einfach: git pull == git fetch + git merge Wenn Sie git pull ausführen, müssen Sie die Daten nicht mit local zusammenführen. Wenn Sie git fetch ausführen, bedeutet dies, dass Sie git merge ausführen müssen, um den neuesten Code auf Ihren lokalen Computer zu übertragen. Andernfalls würde der lokale Maschinencode ohne Zusammenführung nicht geändert. Wenn Sie also in der Git Gui abrufen, müssen Sie die Daten zusammenführen. Durch das Abrufen selbst werden die Codeänderungen bei Ihrem lokalen Benutzer nicht vorgenommen. Sie können dies überprüfen, wenn Sie den Code durch Abrufen aktualisieren einmal holen und sehen; Der Code wird sich nicht ändern. Dann führen Sie zusammen ... Sie sehen den geänderten Code. | git fetch ruft den Code vom Remote-Server zu Ihren Tracking-Zweigen in Ihrem lokalen Repository ab. Wenn Ihre Fernbedienung den Namen origin hat (Standardeinstellung), befinden sich diese Zweige innerhalb von origin /, z. B. origin / master, origin / mybranch-123 usw. Dies sind nicht Ihre aktuellen Zweige, sondern lokale Kopien dieser Zweige vom Server . git pull führt einen git-Abruf durch, führt dann aber auch den Code aus dem Tracking-Zweig in Ihren aktuellen Code einlokale Version dieses Zweigs. Wenn Sie für diese Änderungen noch nicht bereit sind, holen Sie zuerst git fetch. | git fetch ruft entfernte Zweige ab, sodass Sie git diff oder git sie mit dem aktuellen Zweig zusammenführen können. Git Pull führt Fetch auf dem Remote-Brach aus, der vom aktuellen Zweig verfolgt wird, und führt dann das Ergebnis zusammen. Sie können git fetch verwenden, um festzustellen, ob Aktualisierungen für den Remote-Zweig vorhanden sind, ohne diese mit Ihrem lokalen Zweig zusammenführen zu müssen. | Git Fetch Sie laden Änderungen in Ihren lokalen Zweig vom Ursprung durch Abrufen herunter. Fetch fragt das Remote-Repo nach allen Commits, die andere gemacht haben, die Sie jedoch nicht in Ihrem lokalen Repo haben. Fetch lädt diese Commits herunter und fügt sie dem lokalen Repository hinzu. Git Merge Sie können Änderungen, die durch Abrufen heruntergeladen wurden, mit dem Befehl Zusammenführen anwenden. Beim Zusammenführen werden die aus dem Abruf abgerufenen Commits übernommen und versucht, sie Ihrem lokalen Zweig hinzuzufügen. Durch die Zusammenführung wird der Festschreibungsverlauf Ihrer lokalen Änderungen beibehalten, sodass Git weiß, wie andere Ihre Änderungen zusammenführen können, wenn Sie Ihren Zweig mit Push teilen. Git Pull Abrufen und Zusammenführen werden häufig genug ausgeführt, sodass ein Befehl erstellt wurde, der die beiden Elemente "Ziehen" kombiniert. Pull führt einen Abruf und dann eine Zusammenführung durch, um die heruntergeladenen Commits zu Ihrer lokalen Niederlassung hinzuzufügen. | In einfachen Worten, wenn Sie in ein Flugzeug ohne Internetverbindung steigen wollten ... bevor Sie abfliegen, könnten Sie einfach git fetch origin machen. Es würde alle Änderungen in Ihren Computer abrufen, ihn jedoch von Ihrem lokalen Entwicklungs- / Arbeitsbereich trennen. Im Flugzeug können Sie Änderungen an Ihrem lokalen Arbeitsbereich vornehmen und ihn dann mit dem, was Sie abgerufen haben, zusammenführen und potenzielle Zusammenführungskonflikte ohne Verbindung zum Internet lösen. Und wenn nicht jemand neue Änderungen am Remote-Repository vorgenommen hat, würden Sie, sobald Sie am Ziel angekommen sind, git push origin ausführen und Ihren Kaffee holen. Aus diesem fantastischen Atlassian-Tutorial: Der Befehl git fetch lädt Commits, Dateien und Refs von a herunter Remote-Repository in Ihr lokales Repository. Abrufen ist das, was Sie tun, wenn Sie sehen möchten, was alle anderen haben habe daran gearbeitet. Es ähnelt dem SVN-Update, da es Sie sehen lässt wie sich die zentrale Geschichte entwickelt hat, aber es zwingt Sie nicht dazu Führen Sie die Änderungen tatsächlich in Ihrem Repository zusammen. Git isoliert Abgerufener Inhalt als von vorhandenem lokalem Inhalt hat es absolut Keine Auswirkung auf Ihre lokale Entwicklungsarbeit. Abgerufene Inhalte müssen explizit mit dem Befehl git checkout ausgecheckt werden. Das macht Abrufen einer sicheren Methode zum Überprüfen von Commits, bevor diese integriert werden Ihr lokales Repository. Beim Herunterladen von Inhalten aus einem Remote-Repository stehen die Befehle git pull und git fetch zur Verfügung, um die Aufgabe auszuführen. Sie können überlegen git holt die 'sichere' Version der beiden Befehle. Es wird heruntergeladen den Remote-Inhalt, aber nicht den Arbeitsstatus Ihres lokalen Repositorys aktualisieren, Lassen Sie Ihre aktuelle Arbeit intakt. Git Pull ist umso aggressiver Alternativ wird der Remote-Inhalt für den aktiven lokalen heruntergeladen Verzweigen Sie und führen Sie sofort git merge aus, um ein Merge-Commit zu erstellen für den neuen Remote-Inhalt. Wenn Änderungen anstehen Dies führt zu Konflikten und startet die Lösung von Zusammenführungskonflikten fließen. Mit Git Pull: Sie bekommen keine Isolation. Es muss nicht explizit ausgecheckt werden. Weil es implizit eine Git-Zusammenführung macht. Der Zusammenführungsschritt wirkt sich auf Ihre lokale Entwicklung aus und kann zu Konflikten führen Es ist im Grunde NICHT sicher. Es ist aggressiv. Im Gegensatz zum Git-Abruf, bei dem nur Ihre .git / refs / Fernbedienungen betroffen sind, wirkt sich der Git-Pull sowohl auf Ihre .git / refs / Fernbedienungen als auch auf Ihre .git / refs / Köpfe / aus. Hmmm ... also wenn ich die Arbeitskopie nicht mit git fetch aktualisiere, wo nehme ich dann Änderungen vor? Wo speichert Git Fetch die neuen Commits? Gute Frage. Es platziert es irgendwo isoliert von Ihrer Arbeitskopie. Aber wo nochmal? Lass es uns herausfinden. Führen Sie in Ihrem Projektverzeichnis (d. H. Wo Sie Ihre Git-Befehle ausführen) Folgendes aus: ls. Dies zeigt die Dateien und Verzeichnisse. Nichts cooles, ich weiß. Jetzt mach ls -a. Dies zeigt Punktdateien, d. H. Dateien, die mit beginnen. Sie können dann ein Verzeichnis mit dem Namen: .git sehen. Mach cd .git. Dies wird offensichtlich Ihr Verzeichnis ändern. Jetzt kommt der lustige Teil; ls tun. Sie sehen eine Liste der Verzeichnisse. Wir suchen Schiedsrichter. Machen Sie CD-Refs. Es ist interessant zu sehen, was sich in allen Verzeichnissen befindet, aber konzentrieren wir uns auf zwei davon. Köpfe und Fernbedienungen. Verwenden Sie CD, um auch in ihnen zu überprüfen. Bei jedem Git-Abruf werden Elemente im Verzeichnis /.git/refs/remotes aktualisiert. Es wird nichts im Verzeichnis /.git/refs/heads aktualisiert. Bei jedem Git-Pull wird zuerst der Git-Abruf ausgeführt, Elemente im Verzeichnis /.git/refs/remotes aktualisiert, dann mit Ihrem lokalen Verzeichnis zusammengeführt und dann der Kopf im Verzeichnis /.git/refs/heads geändert. Eine sehr gute Antwort finden Sie auch unter Wo platziert sich 'git fetch'?. Suchen Sie auch im Beitrag zu den Namenskonventionen für Git-Zweige nach "Schrägstrichnotation". Es hilft Ihnen besser zu verstehen, wie Git die Dinge platziertverschiedene Verzeichnisse. Um den tatsächlichen Unterschied zu sehen Mach einfach: Git Fetch Origin Master Git Checkout Master Wenn der Remote-Master aktualisiert wurde, wird folgende Meldung angezeigt: Ihre Filiale befindet sich um 2 Commits hinter 'origin / master' und kann schnell weitergeleitet werden. (Verwenden Sie "git pull", um Ihren lokalen Zweig zu aktualisieren.) Wenn Sie nicht git und nur git checkout master ausgeführt haben, würde Ihr lokaler git nicht wissen, dass 2 Commits hinzugefügt wurden. Und es würde nur sagen: Schon auf 'Master' Ihre Filiale ist mit 'origin / master' auf dem neuesten Stand. Aber das ist veraltet und falsch. Das liegt daran, dass Git Ihnen Feedback nur basierend auf dem gibt, was es weiß. Es ist nicht bekannt, dass neue Commits noch nicht abgeschlossen wurden ... Gibt es eine Möglichkeit, die neuen Änderungen zu sehen, die in Remote vorgenommen wurden, während lokal an der Zweigstelle gearbeitet wurde? Einige IDEs (z. B. Xcode) sind sehr intelligent und verwenden das Ergebnis eines Git-Abrufs. Sie können die Codezeilen mit Anmerkungen versehen, die im Remote-Zweig Ihres aktuellen Arbeitszweigs geändert wurden. Wenn diese Zeile sowohl durch lokale Änderungen als auch durch Remote-Verzweigung geändert wurde, wird diese Zeile mit Rot versehen. Dies ist kein Zusammenführungskonflikt. Es ist ein potenzieller Zusammenführungskonflikt. Es ist ein Headsup, mit dem Sie den zukünftigen Zusammenführungskonflikt lösen können, bevor Sie Git Pull aus dem Remote-Zweig ausführen. Spaß Tipp: Wenn Sie einen Remote-Zweig abgerufen haben, z. tat: git fetch origin feature / 123 Dann würde dies in Ihr Fernbedienungsverzeichnis gehen. Es ist immer noch nicht in Ihrem lokalen Verzeichnis verfügbar. Es vereinfacht jedoch das Auschecken zu diesem Remote-Zweig durch DWIM (Tun Sie, was ich meine): Git Checkout-Funktion / 123 Sie müssen nicht mehr tun: Git Checkout -b Feature / 123 Ursprung / Feature / 123 Mehr dazu hier | Der einzige Unterschied zwischen Git Pull und Git Fetch besteht darin, dass: Git Pull zieht von einem entfernten Zweig und führt ihn zusammen. git fetch holt nur vom Remote-Zweig, aber es wird nicht zusammengeführt d.h. Git Pull = Git Fetch + Git Merge ... | Mit Git können chronologisch ältere Commits nach neueren Commits angewendet werden. Aus diesem Grund ist das Übertragen von Commits zwischen Repositorys in zwei Schritte unterteilt: Kopieren neuer Commits von der Remote-Verzweigung in die Kopie dieser Remote-Verzweigung innerhalb des lokalen Repos. (Repo-zu-Repo-Betrieb) master @ remote >> remote / origin / master @ local Integration neuer Commits in die lokale Niederlassung (Inside-Repo-Betrieb) remote / origin / master @ local >> master @ local Es gibt zwei Möglichkeiten, Schritt 2 auszuführen. Sie können: Verzweigen Sie den lokalen Zweig nach dem letzten gemeinsamen Vorfahren und fügen Sie neue Commits parallel zu Commits hinzu, die nur für das lokale Repository gelten. Diese werden durch Zusammenführen des Commits und Schließen des Forks abgeschlossen. Fügen Sie nach dem letzten gemeinsamen Vorfahren neue Commits ein und wenden Sie die für das lokale Repository eindeutigen Commits erneut an. In der Git-Terminologie ist Schritt 1 Git-Abruf, Schritt 2 Git-Merge oder Git-Rebase Git Pull ist Git Fetch und Git Merge | Git ruft mit zwei Befehlen den Zweig der neuesten Version von der Fernbedienung zur lokalen Version ab: git fetch: Git wird die neueste Version von remote auf local übertragen, aber nicht automatisch zusammenführen. Git Fetch Origin Master git log -p master..origin / master Git Merge Origin / Master Die obigen Befehle bedeuten, dass die neueste Version des Hauptzweigs vom Ursprung vom Remote- zum Ursprungshauptzweig heruntergeladen wird. Und vergleicht dann den lokalen Hauptzweig und den Ursprungshauptzweig. Schließlich zusammenführen. git pull: Git wird die neueste Version von der Fernbedienung herunterladen und in die lokale Version einbinden. Git Pull Origin Master Der obige Befehl entspricht git fetch und git merge. In der Praxis ist Git Fetch möglicherweise sicherer, da wir vor dem Zusammenführen die Änderungen sehen und entscheiden können, ob sie zusammengeführt werden sollen. | Was ist der Unterschied zwischen Git Pull und Git Fetch? Um dies zu verstehen, müssen Sie zunächst verstehen, dass Ihr lokaler Git nicht nur Ihr lokales Repository verwaltet, sondern auch eine lokale Kopie des Remote-Repositorys. Mit git fetch wird Ihre lokale Kopie des Remote-Repositorys auf den neuesten Stand gebracht. Wenn Ihr Remote-Repository beispielsweise GitHub ist, möchten Sie möglicherweise alle im Remote-Repository vorgenommenen Änderungen an Ihrer lokalen Kopie des Remote-Repositorys abrufen. Auf diese Weise können Sie Vorgänge wie Vergleichen oder Zusammenführen ausführen. Git Pull hingegen bringt die Änderungen im Remote-Repository dahin, wo Sie Ihren eigenen Code aufbewahren. In der Regel führt Git Pull zuerst einen Git-Abruf durch, um die lokale Kopie des Remote-Repositorys auf den neuesten Stand zu bringen. Anschließend werden die Änderungen in Ihrem eigenen Code-Repository und möglicherweise in Ihrer Arbeitskopie zusammengeführt. | git pull == (git fetch + git merge) git fetch ändert sich nicht in lokale Zweige. Wenn Sie bereits ein lokales Repository mit einer für das gewünschte Projekt eingerichteten Fernbedienung haben, können Sie mit git fetch alle Zweige und Tags für die vorhandene Fernbedienung abrufen. ... Beim Abrufen werden keine Änderungen an lokalen Zweigen vorgenommen. Sie müssen daher einen Remote-Zweig mit einem gepaarten lokalen Zweig zusammenführen, um neu abgerufene Änderungen zu übernehmen. von Github | Eine einfache grafische Darstellung für Anfänger, Hier, Git Pull ruft Code abAus dem Repository und Rebase mit Ihrem lokalen ... In Git Pull besteht die Möglichkeit, dass neue Commits erstellt werden. aber in , Git holen ruft Code aus dem Repository ab und wir müssen ihn manuell mithilfe von git rebase neu starten Beispiel: Ich werde vom Server-Master abrufen und ihn in meinem lokalen Master neu starten. 1) Git Pull (Rebase wird automatisch durchgeführt): Git Pull Origin Master Hier ist der Ursprung Ihr Remote-Repo-Master 2) Git Fetch (muss manuell neu erstellt werden): Git Fetch Origin Master Serveränderungen werden vom Ursprung abgerufen. und es wird in Ihrer Nähe sein, bis Sie es selbst neu starten. Wir müssen Konflikte manuell beheben, indem wir Codes überprüfen. Git Rebase Ursprung / Master Dadurch wird der Code in local zurückgesetzt. Stellen Sie vorher sicher, dass Sie in der richtigen Branche sind. | Der Versuch, klar und einfach zu sein. Der Befehl git pull ist je nach Konfiguration eine Verknüpfung zum Abrufen von Git, gefolgt vom Befehl git merge oder git rebase. Sie können Ihr Git-Repository so konfigurieren, dass Git Pull ein Abruf gefolgt von einer Rebase ist. | Eigentlich verwaltet Git eine Kopie Ihres eigenen Codes und das Remote-Repository. Mit dem Befehl git fetch wird Ihre lokale Kopie aktualisiert, indem Daten aus dem Remote-Repository abgerufen werden. Der Grund, warum wir dies benötigen, ist, dass jemand anderes möglicherweise einige Änderungen am Code vorgenommen hat und Sie sich auf dem Laufenden halten möchten. Der Befehl git pull bringt die Änderungen im Remote-Repository dahin, wo Sie Ihren eigenen Code aufbewahren. Normalerweise führt Git Pull dies durch, indem zuerst ein Git-Abruf durchgeführt wird, um die lokale Kopie des Remote-Repositorys auf den neuesten Stand zu bringen. Anschließend werden die Änderungen in Ihrem eigenen Code-Repository und möglicherweise in Ihrer Arbeitskopie zusammengeführt. | 1 2 Nächster Sehr aktive Frage. Verdiene 10 Reputationen, um diese Frage zu beantworten. Die Reputationsanforderung schützt diese Frage vor Spam und nicht beantworteten Aktivitäten. Nicht die Antwort, die Sie suchen? Durchsuchen Sie andere Fragen mit dem Tag git version-control git-pull git-fetch oder stellen Sie Ihre eigene Frage.